Describe the life cycle of a thread in Java.

Question

Ravi Vishwakarma · Answer

In Java, a thread goes through several states during its life cycle. These states represent the different stages a thread can be in from its creation to its termination.and 
Here is a detailed explanation of the life cycle of a thread in Java:
1. New
State: NEWDescription: A thread is in the NEW state when it is created but not yet started. At this point, the thread has been instantiated, but the
start() the method has not been called.
Thread thread = new Thread(() -> {
    // Task to perform
});
2. Runnable
State: RUNNABLEDescription: A thread enters the RUNNABLE state when the
start() the method is called. In this state, the thread is ready to run and waiting for CPU time. It is also the state where the thread executes its task. However, due to time-sharing and the thread scheduler, a thread in the
RUNNABLE the state may not be actively running.
thread.start(); // Thread transitions to RUNNABLE state
3. Blocked
State: BLOCKEDDescription: A thread enters the BLOCKED state when it attempts to access a synchronized block or method that is currently locked by another thread. The thread remains in this state until the lock is released.
synchronized (someObject) {
    // Thread may become BLOCKED if another thread holds the lock
}
Waiting
State: WAITINGDescription: A thread enters the WAITING state when it is waiting indefinitely for another thread to perform a particular action. This happens when the thread calls methods like
Object.wait() without a timeout, Thread.join() without a timeout, or
LockSupport.park().
synchronized (someObject) {
    someObject.wait(); // Thread enters WAITING state
}
Timed Waiting
State: TIMED_WAITINGDescription: A thread enters the TIMED_WAITING state when it is waiting for a specified period. This can happen when the thread calls methods like
Thread.sleep(long millis), Object.wait(long timeout), 
Thread.join(long millis), or LockSupport.parkNanos(long nanos).
try {
    Thread.sleep(1000); // Thread enters TIMED_WAITING state for 1 second
} catch (InterruptedException e) {
    e.printStackTrace();
}
Terminated
State: TERMINATEDDescription: A thread enters the TERMINATED state when it has finished executing. This can happen either because the thread's
run() the method has been completed, or because an uncaught exception has terminated the thread.
// After the run() method completes
Thread Life Cycle Diagram
NEW -> RUNNABLE andlt;--> BLOCKED
         |           |       |
         V           V       V
    WAITING      TIMED_WAITING
         |
         V
    TERMINATED
Summary of Transitions
NEW to RUNNABLE: When start() is called.RUNNABLE to BLOCKED: When a thread tries to acquire a lock held by another thread.RUNNABLE to WAITING: When Object.wait(), 
Thread.join(), or LockSupport.park() is called.RUNNABLE to TIMED_WAITING: When Thread.sleep(long),
Object.wait(long), Thread.join(long), or LockSupport.parkNanos(long) is called.WAITING to RUNNABLE: When Object.notify(), 
Object.notifyAll(), or the corresponding event occurs.TIMED_WAITING to RUNNABLE: When the specified waiting time elapses.BLOCKED to RUNNABLE: When the thread acquires the lock.RUNNABLE to TERMINATED: When the thread's run() method completes or an uncaught exception terminates the thread.
and 
Read moreand 
Explain the difference between checked and unchecked exceptions. Provide examples.
What are annotations in Java? How are they used?
What is the purpose of the volatile keyword in Java?
and

forum

Describe the life cycle of a thread in Java.

Anubhav Kumar

Can you answer this question?

1 Answers

1. New

2. Runnable

3. Blocked

Waiting

Timed Waiting

Terminated

Liked By